home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / pcr / pcr4_4.lha / DIST / loading / IncrementalLoad.c < prev    next >
C/C++ Source or Header  |  1991-01-18  |  54KB  |  1,931 lines
  1. /* begincopyright
  2.   Copyright (c) 1988 Xerox Corporation. All rights reserved.
  3.   Use and copying of this software and preparation of derivative works based
  4.   upon this software are permitted. Any distribution of this software or
  5.   derivative works must comply with all applicable United States export
  6.   control laws. This software is made available AS IS, and Xerox Corporation
  7.   makes no warranty about the software, its performance or its conformity to
  8.   any specification. Any person obtaining a copy of this software is requested
  9.   to send their name and post office or electronic mail address to:
  10.     PCR Coordinator
  11.     Xerox PARC
  12.     3333 Coyote Hill Rd.
  13.     Palo Alto, CA 94304
  14.   endcopyright */
  15.  
  16. /*
  17.  * IncrementalLoad.c
  18.  *
  19.  * Demers, January 18, 1991 8:20:01 am PST
  20.  * Aizawa, April 6, 1990 3:13:12 pm PDT
  21.  */
  22.  
  23. #include "xr/BasicTypes.h"
  24. #include "xr/Errno.h"
  25. #include "xr/Threads.h"
  26. #include "xr/ThreadsBackdoor.h"
  27. #include "xr/ThreadsTermination.h"
  28.  
  29. #include "xr/ThreadsMsg.h"
  30.  
  31. #include "xr/IncrementalLoad.h"
  32. #include "xr/IncrementalLoadPrivate.h"
  33.  
  34. #include <ctype.h>
  35. #include <fcntl.h>
  36.  
  37. #if defined(UNIX) || defined(UNIXDEBUG)
  38. #include <stdio.h>
  39. #endif
  40.  
  41. #define PREEMPTABLE_READ    1
  42.  
  43. #define DEFAULT_PBYTES_FROM_TBYTES(b) (((unsigned)(b)) >> 6)
  44.  
  45. /*
  46.  * Lock
  47.  */
  48.  
  49. XR_ILError
  50. XR_LockIncrementalLoadState(wait)
  51.     bool wait;
  52. {
  53.     XR_ILSymTab ilst = XR_ilSymTab;
  54.     XR_ILError result = NIL;
  55.  
  56.     XR_MonitorEntry(&(ilst->ilst_ml));
  57.     if( ilst->ilst_locked && (!wait) ) {
  58.         result = XR_ILMakeError(FALSE, ETIMEDOUT, "locked");
  59.         goto Out;
  60.     }
  61.     /* assert: (not locked) || wait */
  62.     while( ilst->ilst_locked ) {
  63.         int waitResult = XR_WaitCV( &(ilst->ilst_avail), &(ilst->ilst_ml) );
  64.         if( waitResult != 0 ) {
  65.             result = XR_ILMakeError( FALSE, XR_EABORTED,
  66.                     "LockIncrementalLoadState: aborted");
  67.             goto Out;
  68.         }
  69.     }
  70.     ilst->ilst_locked = TRUE;
  71. Out:
  72.     XR_MonitorExit(&(ilst->ilst_ml));
  73.     return result;
  74. }
  75.  
  76. XR_ILError
  77. XR_UnlockIncrementalLoadState()
  78. {
  79.     XR_ILSymTab ilst = XR_ilSymTab;
  80.     XR_ILError result = NIL;
  81.  
  82.     XR_MonitorEntry(&(ilst->ilst_ml));
  83.     if( ilst->ilst_locked ) {
  84.         ilst->ilst_locked = FALSE;
  85.         XR_Notify(&(ilst->ilst_avail));
  86.     } else {
  87.         result = XR_ILMakeError( FALSE, EINVAL,
  88.                 "UnlockIncrementalLoadState: not locked");
  89.     }
  90.     XR_MonitorExit(&(ilst->ilst_ml));
  91.     return result;
  92. }
  93.  
  94.  
  95. /*
  96.  *
  97.  * ILFile table stuff
  98.  *
  99.  */
  100.  
  101. static char *
  102. XR_CompressSlashesInPlace(path)
  103.     char *path;
  104. {
  105.     char *from;
  106.     char *to;
  107.     char c;
  108.  
  109.     from = to = path;
  110.     for(;;) {
  111.         c = (*to++ = *from++);
  112.         if( c == 0 ) break;
  113.         if( c == '/' ) {
  114.             while( *from == '/' ) from++;
  115.         }
  116.     }
  117.     to -= 2;
  118.     if( (to > path) && (*to == '/') ) *to = 0;
  119.     return path;
  120. }
  121.  
  122.  
  123. static XR_ILFileTabEntry
  124. XR_ILCreateILFTE(ilst, fName, fOffset)
  125.     XR_ILSymTab ilst;
  126.     char *fName;
  127.     unsigned fOffset;
  128. {
  129.     XR_ILFileTabEntry ilfte;
  130.  
  131.     ilfte = (XR_ILFileTabEntry) XR_PZcalloc(
  132.             ilst->ilst_zone, sizeof(struct XR_ILFileTabEntryRep), 1);
  133.     if( ilfte == NIL ) return NIL;
  134.  
  135.     if( fName != NIL ) {
  136.         extern char *(XR_ExpandPath());
  137.         char *nameCopy = XR_ExpandPath(fName);
  138.         if( nameCopy == NIL ) return NIL;
  139.         if( nameCopy == fName ) {
  140.             nameCopy = (char *)
  141.                 XR_PZmalloc( ilst->ilst_zonePtrFree, strlen(fName)+1 );
  142.             if( nameCopy == NIL ) return NIL;
  143.             strcpy(nameCopy, fName);
  144.         }
  145.         ilfte->ilfte_ilfe.ilfe_fName = XR_CompressSlashesInPlace(nameCopy);
  146.     } else {
  147.         ilfte->ilfte_ilfe.ilfe_fName = "";
  148.     }
  149.  
  150.     ilfte->ilfte_ilfe.ilfe_fOffset = fOffset;
  151.     ilfte->ilfte_ilfe.ilfe_seqNum = ilst->ilst_seqNum;
  152.     ilst->ilst_seqNum += 1;
  153.     return ilfte;
  154. }
  155.  
  156.  
  157. XR_ILFileEntry
  158. XR_ILGetPrevFileEntry(ilfe)
  159.     XR_ILFileEntry ilfe;
  160. {
  161.  
  162.     if( ilfe == NIL ) {
  163.         return ((XR_ILFileEntry)(XR_ilSymTab->ilst_ilfte));
  164.     } else {
  165.         return ( (XR_ILFileEntry) (((XR_ILFileTabEntry)(ilfe))->ilfte_prev) );
  166.     }
  167. }
  168.  
  169.  
  170. /* static */ void
  171. XR_ILAddVersionStamp(ilfe, vMagic, vLen, vStamp)
  172.     XR_ILFileEntry ilfe;
  173.     unsigned vMagic;
  174.     unsigned vLen;
  175.     char * vStamp;
  176. {
  177.     ilfe->ilfe_vMagic = vMagic;
  178.     ilfe->ilfe_vLen = vLen;
  179.     ilfe->ilfe_vStamp = vStamp; 
  180.     ilfe->ilfe_vMagic = vMagic;
  181. }
  182.  
  183.  
  184. XR_ILFileEntry
  185. XR_ILAddVersionStampUsingPC(pc, vMagic, vLen, vStamp)
  186.     caddr_t pc;
  187.     unsigned vMagic;
  188.     unsigned vLen;
  189.     char * vStamp;
  190. {
  191.     XR_ILSymTabEntry ilste;
  192.     XR_ILFileEntry ilfe;
  193.  
  194.     ilste = (XR_ILSymTabEntry) XR_ILLookupSymEntryByValue(pc);
  195.     if( ilste == NIL ) return NIL;
  196.     ilfe = ilste->ilste_ilse.ilse_ilfe;
  197.     XR_ILAddVersionStamp(ilfe, vMagic, vLen, vStamp);
  198.     return ilfe;
  199. }
  200.  
  201.  
  202.  
  203. /*
  204.  * Default GC root stuff
  205.  */
  206.  
  207.  
  208. /*
  209. ??? INTERIM ???
  210. When we commit, we tell the GC (once) about all the
  211. committed roots.  This won't allow us to unload, but currently we
  212. can't do that anyway ...
  213. */
  214.  
  215. static void
  216. XR_ILGCCallback(seg, data)
  217.     XR_Seg seg;
  218.     XR_Pointer data;
  219. {
  220.     extern void XR_add_data_list(/* XR_Pointer low, hi */); /* from GC.h */
  221.  
  222.     if( seg->seg_addr == NIL ) XR_Panic("ILGCCallBack 0");
  223.     if( data != NIL ) XR_Panic("ILGCCallBack 1");
  224.     XR_add_data_list( seg->seg_addr, seg->seg_addr + seg->seg_bytes );
  225. }
  226.  
  227.  
  228. static void
  229. XR_ILTellCollectorAboutRoots(ilst, ilfte)
  230.     XR_ILSymTab ilst;
  231.     XR_ILFileTabEntry ilfte;
  232. {
  233.     if( ilfte->ilfte_gcRootEnumerator != NIL ) {
  234.         (*(ilfte->ilfte_gcRootEnumerator))(
  235.                 XR_ILGCCallback,
  236.                 NIL, 
  237.                 ilfte->ilfte_gcRootEnumeratorData
  238.         );
  239.     } else {
  240.         XR_ConsoleMsg( "ILTellCollectorAboutRoots botch, file %s\n",
  241.             ilfte->ilfte_ilfe.ilfe_fName );
  242.     }
  243. }
  244.  
  245. /*
  246. ??? END of INTERIM stuff
  247. */
  248.  
  249.  
  250. static void
  251. XR_ILDefaultBootFileGCRootEnumerator(gcCallback, gcCallbackData, data)
  252.     XR_GCRootCallback gcCallback /*(XR_Seg seg, XR_Pointer data)*/ ;
  253.     XR_Pointer gcCallbackData;
  254.     XR_Pointer data;
  255. {
  256.     if( XR_sysArea->sa_sharedDataSeg.seg_bytes > 0 )
  257.         (*gcCallback)( &(XR_sysArea->sa_sharedDataSeg), gcCallbackData );
  258. #ifdef XXXX
  259.     if( XR_sysArea->sa_sharedBSSSeg.seg_bytes > 0 )
  260.         (*gcCallback)( &(XR_sysArea->sa_sharedBSSSeg), gcCallbackData );
  261.     if( XR_sysArea->sa_sharedCommonSeg.seg_bytes > 0 )
  262.         (*gcCallback)( &(XR_sysArea->sa_sharedCommonSeg), gcCallbackData );
  263. #endif
  264. }
  265.  
  266.  
  267. static void
  268. XR_ILDefaultGCRootEnumerator(gcCallback, gcCallbackData, data)
  269.     XR_GCRootCallback gcCallback /*(XR_Seg seg, XR_Pointer data)*/ ;
  270.     XR_Pointer gcCallbackData;
  271.     XR_Pointer data;
  272. {
  273.     struct XR_SegRep seg;
  274.     XR_ILFileTabEntry ilfte = ((XR_ILFileTabEntry)(data));
  275. #   define CondCallback(addr,bytes) if( (bytes) > 0 ) { \
  276.         seg.seg_addr = ((XR_Pointer)(addr)); seg.seg_bytes = (bytes); \
  277.         (*gcCallback)( &seg, gcCallbackData ); }
  278.  
  279.     CondCallback(ilfte->ilfte_ilfe.ilfe_dAddr, ilfte->ilfte_ilfe.ilfe_dBytes);
  280.     CondCallback(ilfte->ilfte_ilfe.ilfe_bAddr, ilfte->ilfte_ilfe.ilfe_bBytes);
  281.     CondCallback(ilfte->ilfte_ilfe.ilfe_cAddr, ilfte->ilfte_ilfe.ilfe_cBytes);
  282.  
  283. #   undef CondCallback
  284. }
  285.  
  286.  
  287. void
  288. XR_ILSetGCRootEnumerator(ilst, ilfte, gcRootEnumerator, gcRootEnumeratorData)
  289.     XR_ILSymTab ilst;
  290.     XR_ILFileTabEntry ilfte;
  291.     XR_GCRootEnumerator gcRootEnumerator;
  292.     XR_Pointer gcRootEnumeratorData;
  293. {
  294.     ilfte->ilfte_gcRootEnumerator = NIL;
  295.     ilfte->ilfte_gcRootEnumeratorData = gcRootEnumeratorData;
  296.     ilfte->ilfte_gcRootEnumerator = gcRootEnumerator;
  297. }
  298.  
  299.  
  300. /*
  301.  *
  302.  * Symbol Table
  303.  *
  304.  * Hash table by name of text or external symbols.
  305.  * Skiplist by value of (text, external data, external bss) symbols.
  306.  *
  307.  */
  308.  
  309. #define XR_ILST_INIT_NUM_HDRS    (8*1024) /* must be power of 2 */
  310. #define XR_ILIndexFromHash(hash, numHdrs)  ((hash)&((numHdrs) - 1))
  311.  
  312. #define HEIGHTMASK    0x3
  313. #define HEIGHTSHIFT    2
  314. #define MAXHEIGHT    16
  315.  
  316. static unsigned
  317. XR_ILHeightFromNum(num)
  318.     unsigned num;
  319. {
  320.     int i = 0;
  321.  
  322.     for(;;) {
  323.         if( ((++i) == MAXHEIGHT) || ((num & HEIGHTMASK) != 0) ) return i;
  324.         num >>= HEIGHTSHIFT;
  325.     }
  326. }
  327.  
  328. #define CASE_MASK 0137 /* collapses upper & lower case, other effects too! */
  329.  
  330. unsigned
  331. XR_ILHashFromSym(sym)
  332.     char *sym;
  333. {
  334.     unsigned hash = 0;
  335.     unsigned c;
  336.  
  337.     if( sym == NIL ) return 0;
  338.     for(;;) {
  339.         switch(c = *sym++) {
  340.             case 0:
  341.             case '.':
  342.             case '*':
  343.                 return hash;
  344.         }
  345.         hash = (hash * 5) + (c & CASE_MASK);
  346.     }
  347. }
  348.  
  349.  
  350.  
  351. bool
  352. XR_StrMatchCase(str, pat, caseSensitive)
  353.     char *str;
  354.     char *pat;
  355.     bool caseSensitive;
  356. {
  357.     char sc, pc;
  358.  
  359.     for(;;) {
  360.         if( (pc = *pat++) == '*' ) return TRUE;
  361.         if( (sc = *str++) == 0 ) return ( pc == 0 );
  362.         if( sc != pc ) {
  363.             if( caseSensitive || (pc == 0) ) return FALSE;
  364.             if( isascii(sc) && isupper(sc) ) sc = tolower(sc);
  365.             if( isascii(pc) && isupper(pc) ) pc = tolower(pc);
  366.             if( sc != pc ) return FALSE;
  367.         }
  368.     }
  369. }
  370.  
  371.  
  372.  
  373. static bool
  374. XR_ILTypeIsWanted(theType, wantedTypes, ignoredClasses)
  375.     unsigned theType;
  376.     unsigned wantedTypes;
  377.     unsigned ignoredClasses;
  378. {
  379.     if( theType & ILSE_EXT ) {
  380.         if( ignoredClasses & IGNORE_EXTERNAL ) return FALSE;
  381.     } else {
  382.         if( ignoredClasses & IGNORE_INTERNAL ) return FALSE;
  383.     }
  384.     if( wantedTypes == WANT_ALL_TYPES ) return TRUE;
  385.     return ((theType & ILSE_TYPE) == (wantedTypes & ILSE_TYPE));
  386. }
  387.  
  388.  
  389. static XR_ILSymTabEntry
  390. XR_ILGetMatchingSTEByName(
  391.     ilst, ilste, pat, hash, ulCase, wantedTypes, ignoredClasses, numToSkip
  392. )
  393.     XR_ILSymTab ilst;
  394.     XR_ILSymTabEntry ilste;
  395.     char *pat;
  396.     unsigned hash;
  397.     bool ulCase;
  398.     unsigned wantedTypes;
  399.     unsigned ignoredClasses;
  400.     int numToSkip;
  401. {
  402.     if( ilste == NIL ) {
  403.         unsigned index = XR_ILIndexFromHash(hash, ilst->ilst_numHdrs);
  404.         ilste = ilst->ilst_hdrs[index];
  405.         if( numToSkip > 0 ) numToSkip -= 1;
  406.         else if( numToSkip < 0 ) numToSkip += 1;
  407.         /* else (numToSkip == 0) numToSkip = 0; */
  408.     }
  409.  
  410.     for(;;) {
  411.         if( ilste == NIL ) break;
  412.         if( ilste->ilste_hash == hash ) {
  413.             if( XR_ILTypeIsWanted(ilste->ilste_ilse.ilse_type,
  414.                         wantedTypes, ignoredClasses) ) {
  415.                 if( XR_StrMatchCase(ilste->ilste_ilse.ilse_name,
  416.                         pat, ulCase) ) {
  417.                     if( numToSkip == 0 ) break;
  418.                     else if( numToSkip > 0 ) numToSkip -= 1;
  419.                     else /* numToSkip < 0 */ numToSkip += 1;
  420.                 }
  421.             }
  422.         }
  423.         ilste = ilste->ilste_symNext;
  424.     }
  425.     return ilste;
  426. }
  427.  
  428.  
  429.  
  430. XR_ILSymEntry
  431. XR_ILGetMatchingSymEntryByName(
  432.     ilse, pattern, caseSensitive, wantedTypes, ignoredClasses, numToSkip
  433. ) 
  434.     XR_ILSymEntry ilse;
  435.     char *pattern;
  436.     bool caseSensitive;
  437.     unsigned wantedTypes;
  438.     unsigned ignoredClasses;
  439.     int numToSkip;
  440. {
  441.     unsigned hash;
  442.     XR_ILSymTabEntry ilste = ((XR_ILSymTabEntry)(ilse));
  443.  
  444.     if( pattern == NIL ) {
  445.         if( ilste == NIL ) return NIL;
  446.         pattern = ilste->ilste_ilse.ilse_name;
  447.         hash = ilste->ilste_hash;
  448.     } else {
  449.         hash = XR_ILHashFromSym(pattern);
  450.     }
  451.         
  452.     return ((XR_ILSymEntry)
  453.         XR_ILGetMatchingSTEByName(
  454.             XR_ilSymTab,
  455.             ilste,
  456.             pattern,
  457.             hash,
  458.             caseSensitive,
  459.             wantedTypes,
  460.             ignoredClasses,
  461.             numToSkip
  462.         )
  463.     );
  464. }
  465.  
  466.  
  467. /* could be obsolete, but used internally: */
  468.  
  469. /* static */
  470. XR_ILSymTabEntry
  471. XR_ILLookupSTEByName(ilst, sym, hash, ulCase, extOnly)
  472.     XR_ILSymTab ilst;
  473.     char *sym;
  474.     unsigned hash;
  475.     bool ulCase;
  476.     bool extOnly;
  477. {
  478.     unsigned index;
  479.     XR_ILSymTabEntry ilste;
  480.  
  481.     index = XR_ILIndexFromHash(hash, ilst->ilst_numHdrs);
  482.     ilste = ilst->ilst_hdrs[index];
  483.     for(;;) {
  484.         if( ilste == NIL ) break;
  485.         if( ilste->ilste_hash == hash ) {
  486.             if( (!extOnly) || (ilste->ilste_ilse.ilse_type & ILSE_EXT) ) {
  487.                 if( XR_StrMatchCase(ilste->ilste_ilse.ilse_name, sym, ulCase))
  488.                     break;
  489.             }
  490.         }
  491.         ilste = ilste->ilste_symNext;
  492.     }
  493.     return ilste;
  494. }
  495.  
  496.  
  497. static XR_ILSymTabEntry
  498. XR_ILLookupSTEByValue(val)
  499.     unsigned val;
  500. {
  501.     XR_ILSymTabEntry p, q;
  502.     unsigned h1;
  503.  
  504.     p = XR_ilSymTab->ilst_left;
  505.     if( (h1 = XR_ilSymTab->ilst_maxHeight) > 0 ) {
  506.         h1 -= 1;
  507.         for(;;) {
  508.             q = p->ilste_valNext[h1];
  509.             if( (q == NIL) || (q->ilste_ilse.ilse_value > val) ) {
  510.                 if( h1 == 0 ) break;
  511.                 h1 -= 1;
  512.             } else {
  513.                 p = q;
  514.             }
  515.         }
  516.     }
  517.     return( p );
  518. }
  519.  
  520.  
  521. XR_ILSymEntry
  522. XR_ILGetMatchingSymEntryByValue(
  523.     ilse, val, wantedTypes, ignoredClasses, numToSkip
  524. )
  525.     XR_ILSymEntry ilse;
  526.     unsigned val;
  527.     unsigned wantedTypes;
  528.     unsigned ignoredClasses;
  529.     int numToSkip;
  530. {
  531.     XR_ILSymTabEntry p, left;
  532.     XR_ILSymTabEntry ilste;
  533.  
  534.     ilste = ( (ilse != NIL)
  535.             ? ((XR_ILSymTabEntry)(ilse))
  536.             : XR_ILLookupSTEByValue(val) );
  537.  
  538.     if( ilste == NIL ) /* can't happen */ {
  539. XR_ConsoleMsg("ILGetMatchingSymEntryByValue botch 0\n");
  540.         return NIL;
  541.     }
  542.  
  543.     /* What if the type of *ilse is not in wantedTypes?  Well, ... */
  544.     if( !(XR_ILTypeIsWanted(ilste->ilste_ilse.ilse_type,
  545.             wantedTypes, ignoredClasses)) ) {
  546.         if( numToSkip <= 0 ) numToSkip -= 1;
  547.     }
  548.  
  549.     while( numToSkip < 0 ) {
  550.         left = ((ilste->ilste_ilse.ilse_value == 0)
  551.                 ? XR_ilSymTab->ilst_left
  552.                 : XR_ILLookupSTEByValue(ilste->ilste_ilse.ilse_value-1));
  553.         if( left == ilste ) return NIL;
  554.         for( p = left; p != ilste; p = p->ilste_valNext[0] ) {
  555.             if( XR_ILTypeIsWanted(p->ilste_ilse.ilse_type,
  556.                     wantedTypes, ignoredClasses) )
  557.                 numToSkip += 1;
  558.         }
  559.         ilste = left;
  560.     }
  561.  
  562.     for(;;) {
  563.         if( ilste == NIL ) return NIL;
  564.         if( XR_ILTypeIsWanted(ilste->ilste_ilse.ilse_type,
  565.                 wantedTypes, ignoredClasses) ) {
  566.             if( numToSkip == 0 ) return ((XR_ILSymEntry)(ilste));
  567.             numToSkip -= 1;
  568.         }
  569.         ilste = ilste->ilste_valNext[0];
  570.     }
  571. }
  572.  
  573.  
  574.  
  575. static void
  576. XR_ILGrowST(ilst)
  577.     XR_ILSymTab ilst;
  578. {
  579.     int i, n, newN;
  580.     XR_ILSymTabEntry *newHdrs, *pfrom, *pto;
  581.     XR_ILSymTabEntry t, revList;
  582.  
  583.     n = ilst->ilst_numHdrs;
  584.     newN = n + n;
  585.     newHdrs = (XR_ILSymTabEntry *) XR_calloc(
  586.             2 * n * sizeof(XR_ILSymTabEntry), 1 );
  587.     if( newHdrs == NIL ) return; /* doesn't hurt to fail here ... */
  588.     for( i = 0; i < n; i++ ) {
  589.         pfrom = ilst->ilst_hdrs + i;
  590.         revList = NIL;
  591.         while( *pfrom != NIL ) {
  592.             t = *pfrom;
  593.             *pfrom = t->ilste_symNext;
  594.             t->ilste_symNext = revList;
  595.             revList = t;
  596.         }
  597.         while( revList != NIL ) {
  598.             t = revList;
  599.             revList = t->ilste_symNext;
  600.             pto = newHdrs + XR_ILIndexFromHash(t->ilste_hash, newN);
  601.             t->ilste_symNext = *pto;
  602.             *pto = t;
  603.         }
  604.     }
  605.     ilst->ilst_hdrs = newHdrs;
  606.     ilst->ilst_numHdrs = newN;
  607. }
  608.  
  609.  
  610. static void
  611. XR_ILInsertSTE(ilst, ilste)
  612.     XR_ILSymTab ilst;
  613.     XR_ILSymTabEntry ilste;
  614. {
  615.     unsigned index, h1;
  616.     XR_ILSymTabEntry p, q;
  617.  
  618.     if( ilst->ilst_numEntries >= ilst->ilst_numHdrs ) XR_ILGrowST(ilst);
  619.     index = XR_ILIndexFromHash(ilste->ilste_hash, ilst->ilst_numHdrs);
  620.     ilste->ilste_symNext = ilst->ilst_hdrs[index];
  621.     ilst->ilst_hdrs[index] = ilste;
  622.     /* insert entry in new sym list */
  623.         ilste->ilste_valNext[0] = NIL;
  624.         if( ilst->ilst_newSymsTl == NIL ) {
  625.             ilst->ilst_newSymsHd = ilste;
  626.         } else {
  627.             ilst->ilst_newSymsTl->ilste_valNext[0] = ilste;
  628.         }
  629.         ilst->ilst_newSymsTl = ilste;
  630.     ilst->ilst_numEntries += 1;
  631. }
  632.  
  633.  
  634. static void
  635. XR_ILInsertSTEByValue(ilst, ilste)
  636.     XR_ILSymTab ilst;
  637.     XR_ILSymTabEntry ilste;
  638. {
  639.     unsigned index, h1;
  640.     XR_ILSymTabEntry p, q;
  641.     unsigned newHeight;
  642.  
  643.     newHeight = ilst->ilst_maxHeight;
  644.     ilst->ilst_maxHeight = 1;
  645.     if( newHeight < ilste->ilste_height ) newHeight = ilste->ilste_height;
  646.  
  647.     h1 = newHeight - 1;
  648.     p = ilst->ilst_left;
  649.     for(;;) {
  650.         q = p->ilste_valNext[h1];
  651.         if( (q == NIL)
  652.                 || (q->ilste_ilse.ilse_value > ilste->ilste_ilse.ilse_value) ) {
  653.             if( h1 < ilste->ilste_height ) {
  654.                 ilste->ilste_valNext[h1] = q;
  655.                 p->ilste_valNext[h1] = ilste;
  656.                 if( h1 == 0 ) break;
  657.             }
  658.             h1 -= 1;
  659.         } else {
  660.             p = q;
  661.         }
  662.     }
  663.     ilst->ilst_maxHeight = newHeight;
  664. }
  665.  
  666.  
  667. static XR_ILSymTabEntry
  668. XR_ILMakeSTE(ilst, sym, hash, symType, symValue, symSize)
  669.     XR_ILSymTab ilst;
  670.     char *sym;
  671.     unsigned hash;
  672.     unsigned symType;
  673.     unsigned symValue;
  674.     unsigned symSize;
  675. {
  676.     unsigned height;
  677.     XR_ILSymTabEntry ilste;
  678.     static unsigned seqnum = 1;
  679.         /* there COULD be interference between processors, but this is okay */
  680.  
  681.     height = XR_ILHeightFromNum(seqnum++);
  682.     ilste = (XR_ILSymTabEntry) XR_PZcalloc(
  683.             ilst->ilst_zonePtrFree, XR_ILSymTabEntryBytes(height), 1 );
  684.     if( ilste == NIL ) {
  685.         XR_ILSetError(ilst, TRUE, ENOMEM, "ILMakeSTE: no memory");
  686.         return NIL;
  687.     }
  688.     ilste->ilste_ilse.ilse_name = sym;
  689.     ilste->ilste_ilse.ilse_type = symType;
  690.     ilste->ilste_ilse.ilse_value = symValue;
  691.     ilste->ilste_ilse.ilse_size = symSize;
  692.     ilste->ilste_ilse.ilse_ilfe = (XR_ILFileEntry)(ilst->ilst_ilfte);
  693.     ilste->ilste_hash = hash;
  694.     ilste->ilste_height = height;
  695.     return ilste;
  696. }
  697.  
  698.  
  699.  
  700. static void
  701. XR_ILDeleteSTE(ilst, ilste)
  702.     XR_ILSymTab ilst;
  703.     XR_ILSymTabEntry ilste;
  704. {
  705.     unsigned index;
  706.     int h1;
  707.     XR_ILSymTabEntry p, q;
  708.     unsigned newMaxHeight;
  709.  
  710.     /* delete from hash table */
  711.         index = XR_ILIndexFromHash(ilste->ilste_hash, ilst->ilst_numHdrs);
  712.         p = ilst->ilst_hdrs[index];
  713.         if( p == ilste ) {
  714.             ilst->ilst_hdrs[index] = ilste->ilste_symNext;
  715.         } else {
  716.             while( p->ilste_symNext != ilste ) p = p->ilste_symNext;
  717.             p->ilste_symNext = p->ilste_symNext->ilste_symNext;
  718.         }
  719.         ilst->ilst_numEntries -= 1;
  720.  
  721.     /* delete from skip list if present */
  722.     /* n.b. code must work with multiple instances of same key! */
  723.         if( (newMaxHeight = ilst->ilst_maxHeight) == 0 )
  724.             goto NotInSkipList;
  725.         ilst->ilst_maxHeight = 1;
  726.         h1 = newMaxHeight - 1;
  727.         p = ilst->ilst_left;
  728.         for(;;) {
  729.             q = p->ilste_valNext[h1];
  730.             if( (q == NIL) || (q->ilste_ilse.ilse_value
  731.                     >= ilste->ilste_ilse.ilse_value) ) {
  732.                 if( h1 < ilste->ilste_height ) break;
  733.                 h1 -= 1;
  734.             } else {
  735.                 p = q;
  736.             }
  737.         }
  738.         /* ilste is to right of p in skip list, if present at all */
  739.         /* h1 == ilste->ilste_height - 1, if ilste present at all */
  740.         for(;;) {
  741.             q = p->ilste_valNext[h1];
  742.             if( q == ilste ) {
  743.                 break;
  744.             } else if( (q == NIL) || (q->ilste_ilse.ilse_value
  745.                     > ilste->ilste_ilse.ilse_value) ) {
  746.                 goto NotInSkipList;
  747.             } else {
  748.                 p = q;
  749.             }
  750.         }
  751.         while( h1 >= 0 ) {
  752.             p->ilste_valNext[h1] = q->ilste_valNext[h1];
  753.             h1 -= 1;
  754.         }
  755.         while( (newMaxHeight > 1)
  756.                 && (ilst->ilst_left->ilste_valNext[newMaxHeight-1] == NIL) ) {
  757.             newMaxHeight -= 1;
  758.         }
  759.         
  760.     NotInSkipList: ;
  761.         ilst->ilst_maxHeight = newMaxHeight;
  762.  
  763. }
  764.  
  765. /*
  766.  *
  767.  * Registration stuff
  768.  *
  769.  * Exported to IncrementalLoadPrivate.h
  770.  *
  771.  */
  772.  
  773.  
  774. int
  775. XR_RegisterIncrementalLoadProc(proc, data, nMagics, magics)
  776.     XR_ILReaderProc proc;
  777.     XR_Pointer data;
  778.     int nMagics;
  779.     unsigned *magics;
  780. {
  781.     XR_ILRegistration ilr;
  782.     int i;
  783.  
  784.     ilr = (XR_ILRegistration) XR_malloc(XR_ILRegistrationBytes(nMagics));
  785.     if( ilr == NIL ) {
  786.         XR_SetErrno(ENOMEM);
  787.         return (-ENOMEM);
  788.     }
  789.     ilr->ilr_proc = proc;
  790.     ilr->ilr_data = data;
  791.     ilr->ilr_nMagics = nMagics;
  792.     for( i = 0; i < nMagics; i++ )
  793.         ilr->ilr_magics[i] = magics[i];
  794.     (void)XR_MonitorEntry( &(XR_ilSymTab->ilst_ml) );
  795.     ilr->ilr_next = XR_ilSymTab->ilst_registrations;
  796.     XR_ilSymTab->ilst_registrations = ilr;
  797.     (void)XR_MonitorExit( &(XR_ilSymTab->ilst_ml) );
  798.     return 0;
  799. }
  800.  
  801.  
  802. static bool
  803. XR_ILMagicMatchesRegistration(ilr, m)
  804.     XR_ILRegistration ilr;
  805.     unsigned m;
  806. {
  807.     unsigned *p, *pLim;
  808.  
  809.     if( m == 0 ) return TRUE;
  810.     for( ((p = ilr->ilr_magics),(pLim = p + ilr->ilr_nMagics)); p < pLim; p++ )
  811.         if( *p == m ) return TRUE;
  812.     return FALSE;
  813. }
  814.  
  815.  
  816. /*
  817.  *
  818.  * Utilities for use by registered incremental loading procs
  819.  *
  820.  * Exported to IncrementalLoadPrivate.h
  821.  *
  822.  */
  823.  
  824. static struct XR_ILErrorRep XR_ilNoMemErrorRep = {
  825.     /* ile_fatal */    TRUE,
  826.     /* ile_code */    ENOMEM,
  827.     /* ile_msg */    "out of memory"
  828. };
  829.  
  830.  
  831. XR_ILError
  832. XR_ILMakeError(fatal, code, msg)
  833.     bool fatal;
  834.     int code;
  835.     char * msg;
  836. {
  837.     XR_ILError ile;
  838.  
  839.     ile = (XR_ILError) XR_malloc( sizeof(struct XR_ILErrorRep) );
  840.     if( ile == NIL ) return( &(XR_ilNoMemErrorRep) );
  841.     ile->ile_fatal = fatal;
  842.     ile->ile_code = code;
  843.     if( msg == NIL ) {
  844.         ile->ile_msg = "(no msg)";
  845.     } else {
  846.         ile->ile_msg = (char *) XR_malloc( strlen(msg)+1 );
  847.         if( ile->ile_msg == NIL ) {
  848.             ile->ile_msg = "(no memory for msg)";
  849.         } else {
  850.             strcpy(ile->ile_msg, msg);
  851.         }
  852.     }
  853.     return ile;
  854. }
  855.  
  856. XR_ILError
  857. XR_ILMakeNoMemError()
  858. {
  859.     /* put it in the heap if we can ... */
  860.     return XR_ILMakeError(TRUE, ENOMEM, "out of memory");
  861. }
  862.  
  863.  
  864.  
  865. void
  866. XR_ILGetOpenFile(ilst)
  867.     XR_ILSymTab ilst;
  868. {
  869.     if( ilst->ilst_fd != XR_nullFildes ) return;
  870.  
  871.     ilst->ilst_fd = XR_Open(
  872.             ilst->ilst_ilfte->ilfte_ilfe.ilfe_fName, O_RDONLY, 0 );
  873.     if( ilst->ilst_fd == XR_nullFildes ) {
  874.         XR_ILSetError(ilst, FALSE, XR_GetErrno(),
  875.             "ILGetOpenFile: open error");
  876.     } else {
  877.         struct stat b;
  878.         int ans = XR_FStat(ilst->ilst_fd, &b);
  879.         if( ans < 0 ) {
  880.             XR_ILSetError(ilst, FALSE, XR_GetErrno(),
  881.                 "ILGetOpenFile: stat error");
  882.         } else {
  883.             ilst->ilst_ilfte->ilfte_ilfe.ilfe_fSize = b.st_size;
  884.             ilst->ilst_ilfte->ilfte_ilfe.ilfe_fMTime = b.st_mtime;
  885.             (void)XR_SetGetBlocking(ilst->ilst_fd, XR_UIO_BLOCKING_ALL_DATA);
  886.         }
  887.     }
  888. }
  889.  
  890.  
  891. void
  892. XR_ILCloseFile(ilst)
  893.     XR_ILSymTab ilst;
  894. {
  895.     if( ilst->ilst_fd != XR_nullFildes ) {
  896.         (void) XR_Close(ilst->ilst_fd);
  897.         ilst->ilst_fd = XR_nullFildes;
  898.     }
  899. }
  900.  
  901.  
  902. #if (!PREEMPTABLE_READ)
  903.  
  904. void
  905. XR_ILRead(ilst, offset, buf, bytes, abortOnError)
  906.     XR_ILSymTab ilst;
  907.     unsigned offset;
  908.     char *buf;
  909.     unsigned bytes;
  910.     bool abortOnError;
  911. {
  912.     int ans;
  913.  
  914.     ans = XR_LSeek(ilst->ilst_fd,
  915.             offset+ilst->ilst_ilfte->ilfte_ilfe.ilfe_fOffset, L_SET);
  916.     if( ans < 0 ) goto Bad;
  917.     ans = XR_Read(ilst->ilst_fd, buf, bytes);
  918.     if( ans != bytes ) goto Bad;
  919.     return;
  920.   Bad:
  921.     XR_ILSetError(ilst, abortOnError, XR_GetErrno(), "ILRead: I/O error");
  922. }
  923.  
  924. #else
  925.  
  926. #define READALIGN 1024
  927. #define MAXREAD (16*1024)
  928.  
  929. void
  930. XR_ILRead(ilst, offset, buf, bytes, abortOnError)
  931.     XR_ILSymTab ilst;
  932.     unsigned offset;
  933.     char *buf;
  934.     unsigned bytes;
  935.     bool abortOnError;
  936. {
  937.     int ans, readreq;
  938.  
  939.     if( offset != ((unsigned)(-1)) ) {
  940.         ans = XR_LSeek(ilst->ilst_fd,
  941.                 offset+ilst->ilst_ilfte->ilfte_ilfe.ilfe_fOffset, L_SET);
  942.         if( ans < 0 ) goto Bad;
  943.     }
  944.     if( bytes == 0 ) return;
  945.     for(;;) {
  946.         if( (readreq = bytes) > MAXREAD )
  947.             readreq = MAXREAD - ( ((int)(buf)) & (READALIGN-1) );
  948.         ans = XR_Read(ilst->ilst_fd, buf, readreq);
  949.         if( ans < 0 ) goto Bad;
  950.         buf += ans;
  951.         if( (bytes -= ans) == 0 ) return;
  952.         if( ans == 0 ) goto Bad;
  953.     }
  954.   Bad:
  955.     XR_ILSetError(ilst, abortOnError, XR_GetErrno(), "ILRead: I/O error");
  956. }
  957.  
  958. #endif
  959.  
  960.  
  961. void
  962. XR_ILAllocSegments(ilst, tBytes, dBytes, bBytes)
  963.     XR_ILSymTab ilst;
  964.     unsigned tBytes;
  965.     unsigned dBytes;
  966.     unsigned bBytes;
  967. {
  968.     XR_ILFileEntry ilfe = &(ilst->ilst_ilfte->ilfte_ilfe);
  969.     unsigned pBytes = 0;
  970. #   define ROUNDUPDOUBLE(x) ((((unsigned)(x)) + 0x7) & (~0x7))
  971.  
  972.     ilfe->ilfe_tBytes = tBytes;
  973.     ilfe->ilfe_dBytes = dBytes;
  974.     ilfe->ilfe_bBytes = bBytes;
  975.     ilfe->ilfe_pBytes = pBytes;
  976.  
  977.     if( ilst->ilst_initializationState == ilis_internalizing ) {
  978.         ilfe->ilfe_tAddr = ((caddr_t)(0));
  979.         ilfe->ilfe_dAddr = ((caddr_t)(tBytes));
  980.         ilfe->ilfe_bAddr = ((caddr_t)(tBytes + dBytes));
  981.         ilfe->ilfe_pAddr = ((caddr_t)(NIL));
  982.         return;
  983.     }
  984.  
  985.     ilfe->ilfe_pBytes = ROUNDUPDOUBLE(256 + DEFAULT_PBYTES_FROM_TBYTES(tBytes));
  986.     if( ilst->ilst_activePatchSizeProc != NIL ) {
  987.         (*(ilst->ilst_activePatchSizeProc))(
  988.                 ilfe, ilst->ilst_activePatchSizeClientData );
  989.     }
  990.     ilfe->ilfe_pBytes = ROUNDUPDOUBLE(ilfe->ilfe_pBytes);
  991.     pBytes = ilfe->ilfe_pBytes;
  992.  
  993.     if( (pBytes + tBytes) > 0 ) {
  994.         ilfe->ilfe_pAddr = XR_PZmalloc( ilst->ilst_zonePtrFree,
  995.                 pBytes + tBytes );
  996.         XR_ILCheckAlloc2(ilst, ilfe->ilfe_pAddr);
  997.         ilfe->ilfe_tAddr = (caddr_t)
  998.                 ( ((unsigned)(ilfe->ilfe_pAddr)) + pBytes );
  999.         if( pBytes > 0 ) (void) bzero( ilfe->ilfe_pAddr, pBytes );
  1000.     }
  1001.     if( dBytes > 0 ) {
  1002.         ilfe->ilfe_dAddr = XR_PZmalloc( ilst->ilst_zonePtrFree, dBytes );
  1003.         XR_ILCheckAlloc2(ilst, ilfe->ilfe_dAddr);
  1004.     }
  1005.     if( bBytes > 0 ) {
  1006.         ilfe->ilfe_bAddr = XR_PZcalloc( ilst->ilst_zonePtrFree, bBytes, 1 );
  1007.         XR_ILCheckAlloc2(ilst, ilfe->ilfe_bAddr);
  1008.     }
  1009. }
  1010.  
  1011.  
  1012. static void
  1013. XR_ILDoDeferredRelocation(ilst, ilste)
  1014.     XR_ILSymTab ilst;
  1015.     XR_ILSymTabEntry ilste;
  1016. {
  1017.     XR_ILRelocItem ilri;
  1018.  
  1019.     ilri = ilste->ilste_ilri;
  1020.     ilste->ilste_ilri = NIL;
  1021.     if( ilst->ilst_initializationState >= ilis_internalized ) {
  1022.         while( ilri != NIL ) {
  1023. #           ifdef UNIXDEBUG
  1024.                 printf("ILDRelocate %s ", ilste->ilste_ilse.ilse_name);
  1025.                 printf("addr 0x%x type 0x%x addend 0x%x val 0x%x\n",
  1026.                         ilri->ilri_addr, ilri->ilri_type, ilri->ilri_addend,
  1027.                         ilste->ilste_ilse.ilse_value);
  1028. #           endif
  1029.             (*ilri->ilri_proc) (
  1030.                 ilri->ilri_addr,
  1031.                 ilri->ilri_type,
  1032.                 ilri->ilri_addend,
  1033.                 ilste->ilste_ilse.ilse_value
  1034.             );
  1035.             ilri = ilri->ilri_next;
  1036.         }
  1037.     }
  1038. }
  1039.  
  1040.  
  1041. static void
  1042. XR_ILMoveDeferredRelocationItems(ilst, ilsteOld, ilsteNew)
  1043.     XR_ILSymTab ilst;
  1044.     XR_ILSymTabEntry ilsteOld;
  1045.     XR_ILSymTabEntry ilsteNew;
  1046. {
  1047.     XR_ILRelocItem ilri = NIL;
  1048.  
  1049.     if( ilst->ilst_initializationState < ilis_internalized ) return;
  1050.     if( ilsteOld != NIL ) {
  1051.         ilri = ilsteOld->ilste_ilri;
  1052.         ilsteOld->ilste_ilri = NIL;
  1053.     }
  1054.     if( ilsteNew != NIL ) {
  1055.         ilsteNew->ilste_ilri = ilri;
  1056.     }
  1057. }
  1058.  
  1059.  
  1060. XR_ILSymTabEntry
  1061. XR_ILSetSymDefined(ilst, sym, hash, symType, symValue, symSize)
  1062.     XR_ILSymTab ilst;
  1063.     char *sym;
  1064.     unsigned hash;
  1065.     unsigned symType;
  1066.     unsigned symValue;
  1067. {
  1068.     XR_ILSymTabEntry steOld;
  1069.     XR_ILSymTabEntry steNew;
  1070.     XR_ILContinueAction clientAction;
  1071.  
  1072. #   ifdef UNIXDEBUG
  1073.         if( ilst->ilst_initializationState >= ilis_internalized )
  1074.             printf("ILSetSymDefined(%s, 0x%x, 0x%x)\n", sym, symType, symValue);
  1075. #   endif
  1076.     steNew = XR_ILMakeSTE(ilst, sym, hash, symType, symValue, symSize);
  1077.     if( steNew == NIL ) return NIL;
  1078.     if( (symType & ILSE_EXT) == 0 ) {
  1079.         XR_ILInsertSTE(ilst, steNew);
  1080.         return steNew;
  1081.     }
  1082.     steOld = XR_ILLookupSTEByName(ilst, sym, hash,
  1083.             /*caseSensitive=*/ TRUE, /*externalOnly=*/ TRUE);
  1084.     clientAction = ilca_continue;
  1085.     if( ilst->ilst_activeDefProc != NIL ) {
  1086.         clientAction = (*(ilst->ilst_activeDefProc))(
  1087.             ((XR_ILSymEntry)(steNew)),
  1088.             ((XR_ILSymEntry)(steOld)),
  1089.             ilst->ilst_activeDefClientData
  1090.         );
  1091.     }
  1092.     if( clientAction == ilca_continue ) {
  1093.         clientAction = ( ((steOld != NIL) &&
  1094.                 (steOld->ilste_ilse.ilse_type == (ILSE_UNDF|ILSE_EXT))) 
  1095.             ? ilca_doBind : ilca_dontBind );
  1096.     }
  1097.     switch( clientAction ) {
  1098.         case ilca_doBind:
  1099.             if( (steOld != NIL) &&
  1100.                     (steOld->ilste_ilse.ilse_type == (ILSE_UNDF|ILSE_EXT)) ) {
  1101.                 if( steOld->ilste_ilse.ilse_size == 0 )
  1102.                     /* old symbol wasn't common */
  1103.                     ilst->ilst_numUndefined -= 1;
  1104.                 steOld->ilste_ilse.ilse_type = symType;
  1105.                 steOld->ilste_ilse.ilse_value = symValue;
  1106.                 steOld->ilste_ilse.ilse_size = symSize;
  1107.                 steOld->ilste_ilse.ilse_ilfe =
  1108.                         (XR_ILFileEntry) (ilst->ilst_ilfte);
  1109.                 return steOld;
  1110.             }
  1111.             XR_ILSetError(ilst, TRUE, XR_EABORTED,
  1112.                     "XR_ILSetSymDefined ilca_doBind error");
  1113.             return NIL;
  1114.         case ilca_dontBind:
  1115.             XR_ILMoveDeferredRelocationItems(ilst, steOld, steNew);
  1116.             XR_ILInsertSTE(ilst, steNew);
  1117.             return steNew;
  1118.         default:
  1119.             XR_ILSetError(ilst, TRUE, XR_EABORTED, clientAction);
  1120.             return NIL;
  1121.     }
  1122. }
  1123.  
  1124.  
  1125.  
  1126. XR_ILSymTabEntry
  1127. XR_ILSetSymCommon(ilst, sym, hash, size)
  1128.     XR_ILSymTab ilst;
  1129.     char *sym;
  1130.     unsigned hash;
  1131.     unsigned size;
  1132. {
  1133.     XR_ILSymTabEntry steOld, steNew;
  1134.     XR_ILContinueAction clientAction;
  1135.     
  1136. #   ifdef UNIXDEBUG
  1137.         if( ilst->ilst_initializationState >= ilis_internalized )
  1138.             printf("ILSetSymCommon(%s, %d)\n", sym, size);
  1139. #   endif
  1140.     steOld = XR_ILLookupSTEByName(ilst, sym, hash,
  1141.             /*caseSensitive=*/ TRUE, /*externOnly*/ TRUE);
  1142.     clientAction = ilca_continue;
  1143.     if( ilst->ilst_activeCommonProc != NIL ) {
  1144.         clientAction = (*(ilst->ilst_activeCommonProc))(
  1145.             sym,
  1146.             size,
  1147.             ((XR_ILSymEntry)(steOld)),
  1148.             ilst->ilst_activeCommonClientData
  1149.         );
  1150.     }
  1151.     if( clientAction == ilca_continue ) {
  1152.         clientAction = ((steOld == NIL) ? ilca_dontBind : ilca_doBind);
  1153.     }
  1154.     switch( clientAction ) {
  1155.         case ilca_dontBind:
  1156.             steNew = XR_ILMakeSTE( ilst, sym, hash,
  1157.                     (ILSE_UNDF|ILSE_EXT), 0, size );
  1158.             if( steNew != NIL ) {
  1159.                 XR_ILMoveDeferredRelocationItems(ilst, steOld, steNew);
  1160.                 XR_ILInsertSTE(ilst, steNew);
  1161.             }
  1162.             return steNew;
  1163.         case ilca_doBind:
  1164.             if( steOld != NIL ) {
  1165.                 if( steOld->ilste_ilse.ilse_type == (ILSE_UNDF|ILSE_EXT) ) {
  1166.                     if( steOld->ilste_ilse.ilse_size == 0 )
  1167.                         ilst->ilst_numUndefined -= 1;
  1168.                     if( steOld->ilste_ilse.ilse_size < size )
  1169.                         steOld->ilste_ilse.ilse_size = size;
  1170.                 }
  1171.                 return steOld;
  1172.             }
  1173.             XR_ILSetError(ilst, TRUE, XR_EABORTED,
  1174.                     "XR_ILSetSymCommon ilca_doBind error");
  1175.             return NIL;
  1176.         default:
  1177.             XR_ILSetError(ilst, TRUE, XR_EABORTED, clientAction);
  1178.             return NIL;
  1179.     }
  1180. }
  1181.  
  1182.  
  1183.  
  1184. XR_ILSymTabEntry
  1185. XR_ILSetSymReferenced(ilst, sym, hash)
  1186.     XR_ILSymTab ilst;
  1187.     char *sym;
  1188.     unsigned hash;
  1189. {
  1190.     XR_ILSymTabEntry steOld, steNew;
  1191.     XR_ILContinueAction clientAction;
  1192.  
  1193. #   ifdef UNIXDEBUG
  1194.         if( ilst->ilst_initializationState >= ilis_internalized )
  1195.             printf("ILSetSymReferenced(%s)\n", sym);
  1196. #   endif
  1197.  
  1198.     steOld = XR_ILLookupSTEByName(ilst, sym, hash,
  1199.             /*caseSensitive=*/ TRUE, /*externOnly*/ TRUE);
  1200.     clientAction = ilca_continue;
  1201.     if( ilst->ilst_activeRefProc != NIL ) {
  1202.         clientAction = (*(ilst->ilst_activeRefProc))(
  1203.             sym,
  1204.             ((XR_ILSymEntry)(steOld)),
  1205.             ilst->ilst_activeRefClientData
  1206.         );
  1207.     }
  1208.     if( clientAction == ilca_continue ) {
  1209.         clientAction = ((steOld == NIL) ? ilca_dontBind : ilca_doBind);
  1210.     }
  1211.     switch( clientAction ) {
  1212.         case ilca_dontBind:
  1213.             steNew = XR_ILMakeSTE( ilst, sym, hash,
  1214.                     (ILSE_UNDF|ILSE_EXT), 0, 0 );
  1215.             if( steNew != NIL ) {
  1216.                 XR_ILMoveDeferredRelocationItems(ilst, steOld, steNew);
  1217.                 XR_ILInsertSTE( ilst, steNew );
  1218.                 ilst->ilst_numUndefined += 1;
  1219.             }
  1220.             return steNew;
  1221.         case ilca_doBind:
  1222.             if( steOld != NIL ) return steOld;
  1223.             XR_ILSetError(ilst, TRUE, XR_EABORTED,
  1224.                     "XR_ILSetSymReferenced ilca_doBind error");
  1225.             return NIL;
  1226.         default:
  1227.             XR_ILSetError(ilst, TRUE, XR_EABORTED, clientAction);
  1228.             return NIL;
  1229.     }
  1230. }
  1231.  
  1232.  
  1233.  
  1234. void
  1235. XR_ILRelocate(ilst, ilste, proc, addr, relocType, addend)
  1236.     XR_ILSymTab ilst;
  1237.     XR_ILSymTabEntry ilste;
  1238.     void (*proc)(/*
  1239.         char *addr,
  1240.         unsigned relocType, long addend, unsigned val
  1241.     */);
  1242.     char *addr;
  1243.     unsigned relocType;
  1244.     long addend;
  1245. {
  1246.     XR_ILRelocItem ilri;
  1247.  
  1248.     if( ilst->ilst_initializationState >= ilis_internalized ) {
  1249. #       ifdef UNIXDEBUG
  1250.             printf("ILRelocate sym %s addr 0x%x type 0x%x addend 0x%x ... ",
  1251.                     ilste->ilste_ilse.ilse_name, addr, relocType, addend );
  1252. #       endif
  1253.         if( (ilste->ilste_ilse.ilse_type & ILSE_TYPE) != ILSE_UNDF ) {
  1254. #           ifdef UNIXDEBUG
  1255.                 printf("immediate 0x%x\n", ilste->ilste_ilse.ilse_value);
  1256. #           endif
  1257.             (*proc)(addr, relocType, addend, ilste->ilste_ilse.ilse_value);
  1258.         } else {
  1259.             XR_ILRelocItem ilri;
  1260. #           ifdef UNIXDEBUG
  1261.                 printf("deferred\n");
  1262. #           endif
  1263.             ilri = (XR_ILRelocItem) XR_PZmalloc(
  1264.                 ilst->ilst_zonePerCommit, sizeof(struct XR_ILRelocItemRep) );
  1265.             XR_ILCheckAlloc2(ilst, ilri)
  1266.             ilri->ilri_proc = proc;
  1267.             ilri->ilri_addr = addr;
  1268.             ilri->ilri_type = relocType;
  1269.             ilri->ilri_addend = addend;
  1270.             ilri->ilri_next = ilste->ilste_ilri;
  1271.             ilste->ilste_ilri = ilri;
  1272.         }
  1273.     }
  1274. }
  1275.  
  1276.  
  1277. static void XR_ILRecordCommon();
  1278. static void XR_ILRecordNewFiles();
  1279.  
  1280. /*
  1281.  * Insert new symbols preparatory to commit.
  1282.  * IMPORTANT: this either succeeds or has no effect. 
  1283.  */
  1284. static XR_ILError
  1285. XR_ILInsertNewSymbols(ilst)
  1286.     XR_ILSymTab ilst;
  1287. {
  1288.     XR_ILSymTabEntry ilste;
  1289.     unsigned disp, len, cBytes;
  1290.     caddr_t cAddr;
  1291.  
  1292. #   ifdef UNIXDEBUG
  1293.         printf("ILInsertNewSymbols\n");
  1294. #   endif
  1295.  
  1296.     /* if we're just internalizing symbols, skip common    */
  1297.     /* processing and relocation            */
  1298.         if( ilst->ilst_initializationState == ilis_internalizing ) {
  1299.             ilst->ilst_undefinedSymsHdCache = NIL;
  1300.             while( (ilste = ilst->ilst_newSymsHd) != NIL ) {
  1301.                 ilst->ilst_newSymsHd = ilste->ilste_valNext[0];
  1302.                 ilste->ilste_valNext[0] = NIL;
  1303.                 if( (ilste->ilste_ilse.ilse_type & ILSE_TYPE) != ILSE_ABS ) {
  1304.                     XR_ILInsertSTEByValue(ilst, ilste);
  1305.                 }
  1306.             }
  1307.             ilst->ilst_newSymsTl = NIL;
  1308.             return;
  1309.         }
  1310.  
  1311.     /* compute offsets in common seg for all common defs */
  1312.     /* compute size of common seg                        */
  1313.         disp = 0;
  1314.         for(
  1315.             ilste = ilst->ilst_newSymsHd;
  1316.             ilste != NIL;
  1317.             ilste = ilste->ilste_valNext[0]
  1318.         ) {
  1319.             if( ilste->ilste_ilse.ilse_type != (ILSE_UNDF|ILSE_EXT) )
  1320.                 continue;
  1321.             len = ilste->ilste_ilse.ilse_size;
  1322.             XR_ILAssert( (len > 0), "ILAllocateCommon a0" );
  1323.             if( len & 0x1 ) {
  1324.                 /* nothing */
  1325.             } else if( len & 0x3 ) {
  1326.                 disp = (disp + 0x1) & (~0x1);
  1327.             } else if( len & 0x7 ) {
  1328.                 disp = (disp + 0x3) & (~0x3);
  1329.             } else {
  1330.                 disp = (disp + 0x7) & (~0x7);
  1331.             }
  1332.             ilste->ilste_ilse.ilse_value = disp;
  1333.             disp += len;
  1334.         }
  1335.         cBytes = (disp + 0x7) & (~0x7);
  1336.  
  1337.     /* allocate common segment */
  1338.         cAddr = NIL;
  1339.         if( cBytes > 0 ) {
  1340.             cAddr = (caddr_t) XR_PZcalloc(ilst->ilst_zonePtrFree, cBytes, 1);
  1341.             XR_ILCheckAlloc(cAddr);
  1342.         }
  1343.         ilst->ilst_ilfte->ilfte_ilfe.ilfe_cBytes = cBytes;
  1344.         ilst->ilst_ilfte->ilfte_ilfe.ilfe_cAddr = cAddr;
  1345.  
  1346.     /* define common syms and do deferred relocation, insert syms by value */
  1347.         ilst->ilst_undefinedSymsHdCache = NIL;
  1348.         while( (ilste = ilst->ilst_newSymsHd) != NIL ) {
  1349.             ilst->ilst_newSymsHd = ilste->ilste_valNext[0];
  1350.             ilste->ilste_valNext[0] = NIL;
  1351.             if( ilste->ilste_ilse.ilse_type == (ILSE_UNDF|ILSE_EXT) ) {
  1352.                 ilste->ilste_ilse.ilse_type = (ILSE_BSS|ILSE_EXT);
  1353.                 ilste->ilste_ilse.ilse_value =
  1354.                         (unsigned) (cAddr + ilste->ilste_ilse.ilse_value);
  1355.                 XR_ILRecordCommon(ilst, ilste);
  1356.             }
  1357.             XR_ILDoDeferredRelocation(ilst, ilste); /* can't fail! */
  1358.             if( (ilste->ilste_ilse.ilse_type & ILSE_TYPE) != ILSE_ABS ) {
  1359.                 XR_ILInsertSTEByValue(ilst, ilste);
  1360.             }
  1361.         }
  1362.         ilst->ilst_newSymsTl = NIL;
  1363. }
  1364.  
  1365.  
  1366. static void
  1367. XR_ILDiscardNewSymbols(ilst)
  1368.     XR_ILSymTab ilst;
  1369. {
  1370.     XR_ILSymTabEntry ilste, *hp, *hpLim;
  1371.     unsigned sinceSeqNum;
  1372.  
  1373.     sinceSeqNum = ilst->ilst_ilfte->ilfte_ilfe.ilfe_seqNum;
  1374. #   ifdef UNIXDEBUG
  1375.         printf("ILDiscardNewSymbols(since: %d)\n", sinceSeqNum);
  1376. #   endif
  1377.     ilst->ilst_undefinedSymsHdCache = NIL;
  1378.     ilst->ilst_newSymsHd = NIL;
  1379.     ilst->ilst_newSymsTl = NIL;
  1380.     hp = ilst->ilst_hdrs;
  1381.     hpLim = hp + ilst->ilst_numHdrs;
  1382.     while( hp < hpLim ) {
  1383.         if( ((ilste = *hp) != NIL)
  1384.                 && (ilste->ilste_ilse.ilse_ilfe->ilfe_seqNum > sinceSeqNum) ) {
  1385.             XR_ILDeleteSTE(ilst, ilste);
  1386.         } else {
  1387.             hp++;
  1388.         }
  1389.     }
  1390.     ilst->ilst_numUndefined = 0;
  1391. }
  1392.  
  1393.  
  1394. /*
  1395.  *
  1396.  * Exported to IncrementalLoad.h
  1397.  *
  1398.  */
  1399.  
  1400. bool
  1401. XR_ILSymIsInRecentLoad(ilse)
  1402.     XR_ILSymEntry ilse;
  1403. {
  1404.     XR_ILFileTabEntry ilfte;
  1405.     unsigned seqNum;
  1406.  
  1407.     if( (ilse == NIL) || ((seqNum = ilse->ilse_ilfe->ilfe_seqNum) == 0) )
  1408.         return FALSE;    /* client error, really */
  1409.  
  1410.     ilfte = XR_ilSymTab->ilst_ilfte;
  1411.     for(;;) {
  1412.         if( seqNum >= ilfte->ilfte_ilfe.ilfe_seqNum )
  1413.             /* changed from > to >= April 6, 1990 ajd */
  1414.             return( TRUE );
  1415.         ilfte = ilfte->ilfte_prev;
  1416.         if( ilfte->ilfte_ilfe.ilfe_commitPoint )
  1417.             return( FALSE );
  1418.     }
  1419. }
  1420.  
  1421.  
  1422.  
  1423. XR_Pointer
  1424. XR_ILLookupProc(name, externOnly, recentOnly)
  1425.     char *name;
  1426.     bool externOnly;
  1427.     bool recentOnly;
  1428. {
  1429.     XR_ILSymEntry ilse;
  1430.     XR_Pointer procToCall = NIL;
  1431.  
  1432.     ilse = XR_ILGetMatchingSymEntryByName(
  1433.         /*ilse*/        NIL,
  1434.         /*pattern*/        name,
  1435.         /*caseSensitive*/    TRUE,
  1436.         /*wantedTypes*/        ILSE_TEXT,
  1437.         /*ignoredClasses*/    (externOnly ? IGNORE_INTERNAL : IGNORE_NONE),
  1438.         /*numToSkip*/        0
  1439.     );
  1440.     if( ilse != NIL ) {
  1441.         if( (!recentOnly) || XR_ILSymIsInRecentLoad(ilse) ) {
  1442.             procToCall = ((XR_Pointer)(ilse->ilse_value));
  1443.         }
  1444.     }
  1445.     return procToCall;
  1446. }
  1447.  
  1448.  
  1449.  
  1450. void
  1451. XR_ILEnumerateUndefinedSyms(func, clientData)
  1452.     bool (*func)(/*XR_SymEntry se, void *clientData*/);
  1453.     char *clientData;
  1454. {
  1455.     XR_ILSymTab ilst;
  1456.     XR_ILSymTabEntry ilste;
  1457.  
  1458.     ilst = XR_ilSymTab;
  1459.     if( ilst->ilst_numUndefined == 0 ) return;
  1460.     if( func == NIL ) return;
  1461.     if( (ilste = ilst->ilst_undefinedSymsHdCache) == NIL )
  1462.         ilste = ilst->ilst_newSymsHd;
  1463.     while( ilste != NIL ) {
  1464.         if( ((ilste->ilste_ilse.ilse_type & ILSE_TYPE) == ILSE_UNDF)
  1465.                 && (ilste->ilste_ilse.ilse_size == 0) ) {
  1466.             if( ilst->ilst_undefinedSymsHdCache == NIL )
  1467.                 ilst->ilst_undefinedSymsHdCache = ilste;
  1468.             if( !( (*func)(&(ilste->ilste_ilse), clientData) ) ) return;
  1469.         }
  1470.         ilste = ilste->ilste_valNext[0];
  1471.     }
  1472. }
  1473.  
  1474.  
  1475. static XR_ILError
  1476. XR_ILCallReaderProc(ilst, ilfte, op)
  1477.     XR_ILSymTab ilst;
  1478.     XR_ILFileTabEntry ilfte;
  1479.     XR_ILOp op;
  1480. {
  1481.     XR_ILReaderProc proc;
  1482.     XR_ILError theResult;
  1483.     XR_ILRegistration ilr;
  1484.  
  1485.     if( ilfte == NIL ) XR_Panic("ILCallReaderProc 0");
  1486.     if( (ilr = ilfte->ilfte_ilr) == NIL ) return NIL;
  1487.     if( (proc = ilr->ilr_proc) == NIL ) return NIL;
  1488.     ilst->ilst_opArg = op;
  1489.     ilst->ilst_ilfteArg = ilfte;
  1490.     ilst->ilst_result = NIL;
  1491.     ilst->ilst_readerProcData = ilr->ilr_data;
  1492.     (void) bzero(ilst->ilst_fileData, (sizeof ilst->ilst_fileData));
  1493.             /* not necessary, but ... */
  1494.     (*proc)(ilst);
  1495.     theResult = ilst->ilst_result;
  1496.     ilst->ilst_result = NIL;
  1497.     ilst->ilst_opArg = ilOpNone;
  1498.     ilst->ilst_ilfteArg = NIL;
  1499.     ilst->ilst_readerProcData = NIL;
  1500.     (void) bzero(ilst->ilst_fileData, (sizeof ilst->ilst_fileData));
  1501.     return theResult;
  1502. }
  1503.  
  1504. static void
  1505. XR_ILCommitFiles(ilst, ilfte)
  1506.     XR_ILSymTab ilst;
  1507.     XR_ILFileTabEntry ilfte;
  1508. {
  1509.     XR_ILError ile;
  1510.  
  1511.     if( ilfte == NIL ) XR_Panic("ILCommitFiles 0");
  1512.     if( ilfte->ilfte_ilfe.ilfe_commitPoint ) return;
  1513.     XR_ILCommitFiles(ilst, ilfte->ilfte_prev);
  1514.     ile = XR_ILCallReaderProc(ilst, ilfte, ilOpCommit);
  1515.     if( ile != NIL ) /* this is a reader proc bug */ {
  1516.         XR_ConsoleMsg("ILCommitFile %s error %s\n",
  1517.             ilfte->ilfte_ilfe.ilfe_fName, ile->ile_msg);
  1518.         XR_Panic("ILCommitFiles 1");
  1519.     }
  1520.     if( ilfte->ilfte_gcRootEnumerator == NIL ) {
  1521.         XR_ILSetGCRootEnumerator(
  1522.             ilst,
  1523.             ilfte,
  1524.             ( (ilst->ilst_initializationState >= ilis_internalized)
  1525.                 ? XR_ILDefaultGCRootEnumerator
  1526.                 : XR_ILDefaultBootFileGCRootEnumerator ),
  1527.             ((XR_Pointer)(ilfte))
  1528.         );
  1529.     }
  1530.     /* ??? INTERIM: if not internalizing, notify collector of new roots ??? */
  1531.     if( ilst->ilst_initializationState >= ilis_internalized )
  1532.         XR_ILTellCollectorAboutRoots(ilst, ilfte);
  1533. }
  1534.  
  1535.  
  1536. XR_ILError
  1537. XR_CommitIncrementalLoad()
  1538. {
  1539.     XR_ILSymTab ilst = XR_ilSymTab;
  1540.     XR_ILFileTabEntry ilfte = XR_ilSymTab->ilst_ilfte;
  1541.     XR_ILError result;
  1542.  
  1543.     if( ilst->ilst_numUndefined != 0 ) {
  1544.         return XR_ILMakeError(FALSE, EINVAL,
  1545.                 "CommitIncrementalLoad: undefined symbols exist");
  1546.     }
  1547.  
  1548.     result = XR_ILInsertNewSymbols(ilst);
  1549.     ilfte->ilfte_revertCookie = XR_PZremember(ilst->ilst_zone);
  1550.     ilfte->ilfte_revertCookiePtrFree = XR_PZremember(ilst->ilst_zonePtrFree);
  1551.     XR_ILCommitFiles(ilst, ilfte);
  1552.     XR_ILRecordNewFiles(ilst);
  1553.     ilfte->ilfte_ilfe.ilfe_commitPoint = TRUE;
  1554.     XR_PZrevert(ilst->ilst_zonePerCommit, XR_PZ_FREE_ALL);
  1555.     XR_PZrevert(ilst->ilst_zonePerFile, XR_PZ_FREE_ALL);
  1556.     return NIL;
  1557. }
  1558.  
  1559.  
  1560. static void
  1561. XR_ILDiscardActiveLoads(ilst, target)
  1562.     XR_ILSymTab ilst;
  1563.     XR_ILFileTabEntry target;
  1564. {
  1565.     XR_ILFileTabEntry ilfte;
  1566.     bool sawTarget;
  1567.     XR_ILRegistration ilr;
  1568.     XR_ILReaderProc proc;
  1569.  
  1570.     sawTarget = (target == NIL);
  1571. XR_LogVMsg "DiscardActiveLoads target 0x%x\n", target);
  1572.     ilfte = ilst->ilst_ilfte;
  1573.     for(;;) {
  1574.         if( ilfte == NIL ) break;
  1575.         if( (ilfte->ilfte_ilfe.ilfe_commitPoint) && sawTarget ) break;
  1576.         (void)XR_ILCallReaderProc(ilst, ilfte, ilOpAbort);
  1577.         if( ilfte == target ) sawTarget = TRUE;
  1578.         ilfte = ilfte->ilfte_prev;
  1579.     }
  1580.     ilst->ilst_ilfte = ilfte;
  1581.  
  1582. XR_LogVMsg "DiscardActiveLoads about to discard symbols ...\n");
  1583.     XR_ILDiscardNewSymbols(ilst);
  1584. XR_LogVMsg "DiscardActiveLoads about to free memory ...\n");
  1585.     XR_PZrevert(ilst->ilst_zone, ilfte->ilfte_revertCookie);
  1586.     XR_PZrevert(ilst->ilst_zonePtrFree, ilfte->ilfte_revertCookiePtrFree);
  1587.     XR_PZrevert(ilst->ilst_zonePerFile, XR_PZ_FREE_ALL);
  1588.     XR_PZrevert(ilst->ilst_zonePerCommit, XR_PZ_FREE_ALL);
  1589. XR_LogVMsg "DiscardActiveLoads done\n");
  1590. }
  1591.  
  1592.  
  1593. XR_ILError
  1594. XR_AbortIncrementalLoad(ilfe)
  1595.     XR_ILFileEntry ilfe;
  1596. {
  1597.     XR_ILSymTab ilst = XR_ilSymTab;
  1598.     XR_ILDiscardActiveLoads( ilst, ((XR_ILFileTabEntry)(ilfe)) );
  1599.     return NIL;
  1600. }
  1601.  
  1602.  
  1603. XR_ILError
  1604. XR_ILLoadFile(fName, fOffset, fMagic,
  1605.         refProc, refClientData, defProc, defClientData,
  1606.         commonProc, commonClientData, patchSizeProc, patchSizeClientData)
  1607.     char *fName;
  1608.     long fOffset;
  1609.     unsigned fMagic;
  1610.     XR_ILContinueAction (*refProc)(/*
  1611.         char *sym,
  1612.         XR_ILSymEntry ilseOld,
  1613.         void *clientData
  1614.     */);
  1615.     char *refClientData;
  1616.     XR_ILContinueAction (*defProc)(/*
  1617.         XR_ILSymEntry ilseNew,
  1618.         XR_ILSymEntry ilseOld,
  1619.         void *clientData
  1620.     */);
  1621.     char *defClientData;
  1622.     XR_ILContinueAction (*commonProc)(/*_
  1623.         char *sym,
  1624.         unsigned size,
  1625.         XR_ILSymEntry ilseOld,
  1626.         void *clientData
  1627.     */);
  1628.     char *commonClientData;
  1629.     void (*patchSizeProc)(/*
  1630.         XR_ILFileEntry ilfe,
  1631.         void *clientData
  1632.     */);
  1633.     char *patchSizeClientData;
  1634. {
  1635.     XR_ILSymTab ilst = XR_ilSymTab;
  1636.     XR_ILRegistration ilr;
  1637.     XR_ILFileTabEntry ilfte;
  1638.     XR_ILError theResult = NIL;
  1639.  
  1640.     if( ilst == NIL ) XR_Panic("XR_ILLoadFile 0");
  1641.     if( ilst->ilst_initializationState < ilis_internalizing ) {
  1642.         return XR_ILMakeError( TRUE, EINVAL,
  1643.                 "ILLoadFile: uninitialized" );
  1644.     }
  1645.     if( ilst->ilst_fd != (-1) ) XR_Panic("XR_ILLoadFile 1");
  1646.     ilst->ilst_fd = -1; /* redundant ??? */
  1647.  
  1648.     /*
  1649.      * Set up ...
  1650.      */
  1651.  
  1652.     /* create file table entry */
  1653.         ilfte = XR_ILCreateILFTE(ilst, fName, fOffset);
  1654.         XR_ILCheckAlloc(ilfte);
  1655.         ilfte->ilfte_prev = ilst->ilst_ilfte;
  1656.         ilst->ilst_ilfte = ilfte;
  1657.     /* store callbacks for reader proc */
  1658.         ilst->ilst_activeRefProc = refProc;
  1659.         ilst->ilst_activeRefClientData = refClientData;
  1660.         ilst->ilst_activeDefProc = defProc;
  1661.         ilst->ilst_activeDefClientData = defClientData;
  1662.         ilst->ilst_activeCommonProc = commonProc;
  1663.         ilst->ilst_activeCommonClientData = commonClientData;
  1664.         ilst->ilst_activePatchSizeProc = patchSizeProc;
  1665.         ilst->ilst_activePatchSizeClientData = patchSizeClientData;
  1666.  
  1667.     /*
  1668.      * Try each registered reader in turn ...
  1669.      */
  1670.  
  1671.     for(
  1672.         ilr = XR_ilSymTab->ilst_registrations;
  1673.         ilr != NIL;
  1674.         ilr = ilr->ilr_next
  1675.     ) {
  1676.         if( !XR_ILMagicMatchesRegistration(ilr, fMagic) ) continue;
  1677.         /* store reader proc id in file table */
  1678.             ilfte->ilfte_ilfe.ilfe_fMagic = fMagic;
  1679.             ilfte->ilfte_ilr = ilr;
  1680.             ilfte->ilfte_readerPrivateState = NIL;
  1681.         /* call the proc */
  1682.             theResult = XR_ILCallReaderProc(
  1683.                 ilst,
  1684.                 ilfte,
  1685.                 ( (ilst->ilst_initializationState >= ilis_internalized)
  1686.                         ? ilOpLoad
  1687.                         :  ilOpInternalize)
  1688.             );
  1689.         /* if successful, break */
  1690.             if( theResult == NIL ) goto Done;
  1691.         /* reader proc failed ... remove reader proc id from file table */
  1692.             ilfte->ilfte_ilr = NIL;
  1693.             ilfte->ilfte_readerPrivateState = NIL;
  1694.         /* analyze failure code to decide whether to continue or abort */
  1695.             if( theResult->ile_fatal ) goto Done;
  1696.             switch( theResult->ile_code ) {
  1697.               /* errors specific to this load proc */
  1698.                 case EDOM:
  1699.                     /* "domain error" -- magic was 0, but I can't parse file */
  1700.                     continue;
  1701.                 case ENOEXEC:
  1702.                     /* "no exec" -- file not specified format, or garbage */
  1703.                     goto Done;
  1704.               /* errors that all load procs may encounter */
  1705.                 case ENOENT:
  1706.                 case EACCES:
  1707.                     goto Done;
  1708.               /* unknown errors */
  1709.                 default:
  1710.                     continue;
  1711.             }
  1712.     }
  1713.     /* fell thru -- didn't find applicable loader */
  1714.         theResult = XR_ILMakeError(FALSE, EINVAL,
  1715.                 "ILLoadFile: unknown file type");
  1716.  
  1717.     /*
  1718.      * Done -- success or hard failure ...
  1719.      */
  1720.  
  1721.   Done:
  1722.  
  1723.     /* close file if open */
  1724.         XR_ILCloseFile(ilst);
  1725.     /* clean up reader proc callbacks */
  1726.         ilst->ilst_activeRefProc = NIL;
  1727.         ilst->ilst_activeRefClientData = NIL;
  1728.         ilst->ilst_activeDefProc = NIL;
  1729.         ilst->ilst_activeDefClientData = NIL;
  1730.         ilst->ilst_activeCommonProc = NIL;
  1731.         ilst->ilst_activeCommonClientData = NIL;
  1732.         ilst->ilst_activePatchSizeProc = NIL;
  1733.         ilst->ilst_activePatchSizeClientData = NIL;
  1734.     /* discard data from unsuccessful loads */
  1735.         if( theResult != NIL ) {
  1736.             if( theResult->ile_fatal ) {
  1737.                 XR_ILDiscardActiveLoads(ilst, NIL);
  1738.             } else {
  1739.                 ilst->ilst_ilfte = ilst->ilst_ilfte->ilfte_prev;
  1740.             }
  1741.         }
  1742.     /* free temporary space */
  1743.         XR_PZrevert(ilst->ilst_zonePerFile, XR_PZ_FREE_ALL);
  1744.  
  1745.     return theResult;
  1746. }
  1747.  
  1748.  
  1749. static void XR_ILInitInfoFile();
  1750.  
  1751. /*
  1752.  * Start of the world ...
  1753.  */
  1754.  
  1755. XR_ILError
  1756. XR_InitializeIncrementalLoader(fName)
  1757.     char *fName;
  1758. {
  1759.     extern void XR_run_IncrementalLoadDEFAULT();
  1760.  
  1761.     XR_ILError theResult = NIL;
  1762.     XR_ILSymTab ilst = XR_ilSymTab;
  1763.     XR_ILFileTabEntry ilfte;
  1764.     XR_ILSymTabEntry ilste;
  1765.  
  1766.     if( ilst->ilst_initializationState == ilis_initial ) {
  1767.         /* finish initialization of *ilst */
  1768.         XR_InitializeMonitor(&(ilst->ilst_ml));
  1769.         XR_InitializeCondition(&(ilst->ilst_avail), XR_WAIT_FOREVER);
  1770.         XR_EnableAborts(&(ilst->ilst_avail));
  1771.         ilst->ilst_numHdrs = XR_ILST_INIT_NUM_HDRS;
  1772.         ilst->ilst_hdrs = (XR_ILSymTabEntry *) XR_calloc(
  1773.                 XR_ILST_INIT_NUM_HDRS * sizeof(XR_ILSymTabEntry), 1 );
  1774.         XR_ILCheckAlloc( ilst->ilst_hdrs );
  1775.         ilfte = XR_ILCreateILFTE(ilst, NIL, 0);
  1776.         XR_ILCheckAlloc( ilfte );
  1777.         ilfte->ilfte_ilfe.ilfe_commitPoint = TRUE;
  1778.         ilfte->ilfte_revertCookie = XR_PZ_FREE_ALL;
  1779.         ilfte->ilfte_revertCookiePtrFree = XR_PZ_FREE_ALL;
  1780.         ilst->ilst_ilfte = ilfte;
  1781.         ilste = (XR_ILSymTabEntry) XR_calloc(
  1782.                 XR_ILSymTabEntryBytes(MAXHEIGHT), 1 );
  1783.         XR_ILCheckAlloc( ilste );
  1784.         ilste->ilste_height = MAXHEIGHT;
  1785.         ilste->ilste_ilse.ilse_ilfe = ((XR_ILFileEntry)(ilfte));
  1786.         ilst->ilst_left = ilste;
  1787.         ilst->ilst_fd = -1;
  1788.         ilst->ilst_zonePerFile = XR_PZCreate(FALSE, 0);
  1789.         XR_ILCheckAlloc( ilst->ilst_zonePerFile );
  1790.         ilst->ilst_zonePerCommit = XR_PZCreate(FALSE, 0);
  1791.         XR_ILCheckAlloc( ilst->ilst_zonePerCommit );
  1792.         ilst->ilst_zone = XR_PZCreate(FALSE, 0);
  1793.         XR_ILCheckAlloc( ilst->ilst_zone );
  1794.         ilst->ilst_zonePtrFree = XR_PZCreate(TRUE, 0);
  1795.         XR_ILCheckAlloc( ilst->ilst_zonePtrFree );
  1796.         XR_ILInitInfoFile(ilst);
  1797.         ilst->ilst_initializationState = ilis_allocated;
  1798.     }
  1799.  
  1800.     XR_run_IncrementalLoadDEFAULT();
  1801.  
  1802.     theResult = XR_LockIncrementalLoadState(TRUE);
  1803.     if( theResult != NIL ) return theResult;
  1804.  
  1805.     if( fName == NIL ) XR_Panic("InitializeIncrementalLoader 0");
  1806.  
  1807.     ilst->ilst_initializationState = ilis_internalizing;
  1808.     theResult = XR_ILLoadFile(
  1809.             /* file name */ fName,
  1810.             /* offset */ 0,
  1811.             /* fMagic */ 0,
  1812.             /* refProc */ NIL,
  1813.             /* refClientData */
  1814.             /* defProc */ NIL,
  1815.             /* defClientData */ NIL,
  1816.             /* commonProc */ NIL,
  1817.             /* commonClientData */ NIL,
  1818.             /* patchSizeProc */ NIL,
  1819.             /* patchSizeClientData */ NIL
  1820.     );
  1821.     if( theResult == NIL ) {
  1822.         theResult = XR_CommitIncrementalLoad();
  1823.         ilst->ilst_initializationState = ilis_internalized;
  1824.     }
  1825.     if( theResult != NIL ) {
  1826.         (void) XR_AbortIncrementalLoad();
  1827.         ilst->ilst_initializationState = ilis_allocated;
  1828.         theResult->ile_fatal = TRUE;
  1829.     }
  1830.  
  1831.     (void) XR_UnlockIncrementalLoadState();
  1832.     return theResult;
  1833. }
  1834.  
  1835.  
  1836. /*
  1837.  * Setup -- called before virtual processors are forked
  1838.  */
  1839.  
  1840. XR_ILSymTab XR_ilSymTab = NIL;
  1841.  
  1842. void
  1843. XR_SetupIncrementalLoader()
  1844. {
  1845.     XR_ILSymTab ilst;
  1846.  
  1847.     /*
  1848.      * allocate symbol table struct
  1849.      *
  1850.      * leave remaining initialization to XR_InitializeIncrementalLoader()
  1851.      */
  1852.     ilst = (XR_ILSymTab)
  1853.             XR_AllocSharedSysMem( sizeof(struct XR_ILSymTabRep) );
  1854.     (void) bzero( ilst, sizeof(struct XR_ILSymTabRep) );
  1855.     XR_ilSymTab = ilst;
  1856. }
  1857.  
  1858. /*
  1859.  * dbx initialization file
  1860.  */
  1861.  
  1862. static void
  1863. XR_ILRecordCommon(ilst, ilste)
  1864.     XR_ILSymTab ilst;
  1865.     XR_ILSymTabEntry ilste;
  1866. {
  1867.     /* write the entry for the common symbol in the file-and-commons-info */
  1868.     if (ilst->ilst_infoFile == -1) return;
  1869.     XR_Msg(ilst->ilst_infoFile, "C: %x %s\n",
  1870.         ilste->ilste_ilse.ilse_value,
  1871.         ilste->ilste_ilse.ilse_name );
  1872. }
  1873.  
  1874. static void
  1875. XR_ILRecordNewFiles(ilst)
  1876.     XR_ILSymTab ilst;
  1877. {
  1878.     /* write the entry for the new files in the file-and-commons-info */
  1879.     XR_ILFileTabEntry ilfte;
  1880.     XR_Fildes fd;
  1881.     if ((fd = ilst->ilst_infoFile) == -1) return;
  1882.     ilfte = ilst->ilst_ilfte;
  1883.     while( !(ilfte->ilfte_ilfe.ilfe_commitPoint) ) {
  1884.         /* write the record for ilfte */
  1885.         XR_Msg(fd, "F: %x %x %x %x %s\n", 
  1886.             ilfte->ilfte_ilfe.ilfe_tAddr,
  1887.             ilfte->ilfte_ilfe.ilfe_dAddr,
  1888.             ilfte->ilfte_ilfe.ilfe_bAddr,
  1889.             ilfte->ilfte_ilfe.ilfe_fOffset,
  1890.             ilfte->ilfte_ilfe.ilfe_fName );
  1891.         ilfte = ilfte->ilfte_prev;
  1892.     }
  1893.     
  1894. }
  1895.  
  1896. void
  1897. XR_ILGetInfoFileName(buf)
  1898.     char *buf;
  1899. {
  1900.     char *(XR_get_loader_directory());
  1901.     int XR_GetPID();
  1902.  
  1903.     XR_SPrintF(buf, "%s/ILsymtab.pid%d", 
  1904.             XR_get_loader_directory(), XR_GetPID() );
  1905. }
  1906.  
  1907. static void
  1908. XR_ILCleanUpInfoFile(name)
  1909.     char *name;
  1910. {
  1911.     (void)unlink(name);
  1912. }
  1913.  
  1914. static void (*XR_ilCleanUpInfoFile) = XR_ILCleanUpInfoFile;
  1915.  
  1916. static void
  1917. XR_ILInitInfoFile(ilst)
  1918.      XR_ILSymTab ilst;
  1919. {
  1920.     char *name = (char *) XR_pointerfree_new(256);
  1921.     XR_ILGetInfoFileName(name);
  1922.     ilst->ilst_infoFileName = name;
  1923.     if ((ilst->ilst_infoFile = 
  1924.         XR_Open(name, O_RDWR | O_TRUNC | O_CREAT, 0777)) < 0) {
  1925.         ilst->ilst_infoFile = -1;
  1926.     }
  1927.     (void)XR_RegisterTerminationCleanupProc(
  1928.         &XR_ilCleanUpInfoFile, name );
  1929. }  /* XR_ILInitInfoFile */
  1930.  
  1931.